package linked;

import javax.swing.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;

public class TestMain {
    static int testa = 100;
    public static void main(String[] args) throws IOException {
        /*从输入任意个整型数，统计其中的负数个数并求所有非负数的平均值，结果保留一位小数，如果没有非负数，则平均值为0
        本题有多组输入数据，输入到文件末尾，请使用while(cin>>)读入*/
    }
    public static void testMain(int a){
        System.out.println(a);
    }

    public static int longestSubarray(int[] nums) {
        HashMap<Integer,Integer> inter = new HashMap<>();
        int begin = 0;
        int end = 0;
        boolean flag = false;  //true说明当前在1区间  false为非1区间
        for (int a =0;a<nums.length;a++){
            if (flag == false && nums[a] == 1){
                flag = true;
                begin = a ;
            }
            if (flag && nums[a] == 0  ){
                flag = false;
                end = a-1;
                inter.put(begin,end);
            }
            if (flag && a==nums.length-1){
                end = a;
                inter.put(begin,end);
            }
        }
        System.out.println(inter.toString());
        int max = 0;
        Set<Integer> set= inter.keySet();
        Iterator<Integer> it = set.iterator();
        while (it.hasNext()){
            int a = it.next();
            int b = inter.get(a);
            System.out.println(a+" || "+b);
            int len =  b- a + 1;
            int nextLen = 0;
            if (set.contains(b+2)){
                nextLen =inter.get(b+2) -(b+2) + 1;
            }
            System.out.println(len+ " // " +nextLen);
            max =max > (len+nextLen) ? max :(len+nextLen);
        }

        if (max == nums.length){
            return --max;
        }

        return max;
    }



    /*
    * threshold  门槛值
    * 解题思路  数字中横纵坐标和为临界值的点的个数  就是不能到达的地方数 其余都是可以到达的
    * 关键在于遍历的时候如何防止重复遍历  可以考虑使用一个哈希表将已经遍历了的点添加进去
    * */




    // 反转单向链表
    public static NodeTest.Node reverseList(NodeTest.Node head) {
        NodeTest.Node temp = null;
        NodeTest.Node pre = null;
        while (head != null) {
            temp = head.next;// 备份
            head.next = pre;
            pre = head;
            head = temp;
        }
        return pre;// 因为head是在为空的时候退出的循环，所以应该返回他的上一节点
    }
    // 打印单向链表
    public static void printList(NodeTest.Node head) {
        System.out.print("Linked List:");
        while (head != null) {
            System.out.print(head.value + " ");
            head = head.next;
        }
        System.out.println();
    }
        //遍历输出链表
    public static void printAll(NodeTest.Node node){
        while (node!=null){
            System.out.print(node.value);
            node=node.next;
        }
    }

}
